home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 August: Tool Chest / Dev.CD Aug 95 TC / Dev.CD Aug 95 TC.toast / Tool Chest / Interfaces / UniversalInterfaces 2.0 / PInterfaces / PPCToolbox.p < prev    next >
Encoding:
Text File  |  1995-04-18  |  14.8 KB  |  504 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        PPCToolbox.p
  3.  
  4.      Contains:    Program-Program Communications Toolbox Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT PPCToolbox;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __PPCTOOLBOX__}
  30. {$SETC __PPCTOOLBOX__ := 1}
  31.  
  32. {$I+}
  33. {$SETC PPCToolboxIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __APPLETALK__}
  38. {$I AppleTalk.p}
  39. {$ENDC}
  40. {    Types.p                                                        }
  41. {        ConditionalMacros.p                                        }
  42. {    OSUtils.p                                                    }
  43. {        MixedMode.p                                                }
  44. {        Memory.p                                                }
  45.  
  46. {$IFC UNDEFINED __MEMORY__}
  47. {$I Memory.p}
  48. {$ENDC}
  49.  
  50. {$IFC UNDEFINED __TYPES__}
  51. {$I Types.p}
  52. {$ENDC}
  53.  
  54. {$PUSH}
  55. {$ALIGN MAC68K}
  56. {$LibExport+}
  57.     
  58. TYPE
  59.     PPCServiceType = CHAR;
  60.  
  61.  
  62. CONST
  63.     ppcServiceRealTime            = 1;
  64.  
  65.     
  66. TYPE
  67.     PPCLocationKind = INTEGER;
  68.  
  69.  
  70. CONST
  71.     ppcNoLocation                = 0;                            { There is no PPCLocName }
  72.     ppcNBPLocation                = 1;                            { Use AppleTalk NBP      }
  73.     ppcNBPTypeLocation            = 2;                            { Used for specifying a location name type during PPCOpen only }
  74.  
  75.     
  76. TYPE
  77.     PPCPortKinds = INTEGER;
  78.  
  79.  
  80. CONST
  81.     ppcByCreatorAndType            = 1;                            { Port type is specified as colloquial Mac creator and type }
  82.     ppcByString                    = 2;                            { Port type is in pascal string format }
  83.  
  84. { Values returned for request field in PPCInform call }
  85.     
  86. TYPE
  87.     PPCSessionOrigin = CHAR;
  88.  
  89.  
  90. CONST
  91. { Values returned for requestType field in PPCInform call }
  92.     ppcLocalOrigin                = 1;                            { session originated from this machine }
  93.     ppcRemoteOrigin                = 2;                            { session originated from remote machine }
  94.  
  95.     
  96. TYPE
  97.     PPCPortRefNum = INTEGER;
  98.  
  99.     PPCSessRefNum = LONGINT;
  100.  
  101.     PPCPortRec = RECORD
  102.         nameScript:                ScriptCode;                                { script of name }
  103.         name:                    Str32;                                    { name of port as seen in browser }
  104.         portKindSelector:        PPCPortKinds;                            { which variant }
  105.         CASE INTEGER OF
  106.         0: (
  107.             portTypeStr:                Str32;                                { pascal type string }
  108.            );
  109.         1: (
  110.             portCreator:                OSType;
  111.             portType:                    OSType;
  112.            );
  113.     END;
  114.  
  115.     PPCPortPtr = ^PPCPortRec;
  116.  
  117.     LocationNameRec = RECORD
  118.         locationKindSelector:    PPCLocationKind;                        { which variant }
  119.         CASE INTEGER OF
  120.         0: (
  121.             nbpEntity:                    EntityName;                            { NBP name entity }
  122.            );
  123.         1: (
  124.             nbpType:                    Str32;                                { just the NBP type string, for PPCOpen }
  125.            );
  126.     END;
  127.  
  128.     LocationNamePtr = ^LocationNameRec;
  129.  
  130.     PortInfoRec = RECORD
  131.         filler1:                SInt8; (* unsigned char *)
  132.         authRequired:            BOOLEAN;
  133.         name:                    PPCPortRec;
  134.     END;
  135.  
  136.     PortInfoPtr = ^PortInfoRec;
  137.  
  138.     PortInfoArrayPtr = ^PortInfoRec;
  139.  
  140.     PPCParamBlockPtr = ^PPCParamBlockRec;
  141.  
  142.     PPCCompProcPtr = ProcPtr;  { PROCEDURE PPCComp(pb: PPCParamBlockPtr); }
  143.     PPCCompUPP = UniversalProcPtr;
  144.  
  145.     PPCOpenPBRec = PACKED RECORD
  146.         qLink:                    Ptr;
  147.         csCode:                    INTEGER;
  148.         intUse:                    INTEGER;
  149.         intUsePtr:                Ptr;
  150.         ioCompletion:            PPCCompUPP;
  151.         ioResult:                OSErr;
  152.         Reserved:                ARRAY [0..4] OF LONGINT;
  153.         portRefNum:                PPCPortRefNum;                            { 38 <--   Port Reference }
  154.         filler1:                LONGINT;
  155.         serviceType:            PPCServiceType;                            { 44 -->    Bit field describing the requested port service }
  156.         resFlag:                UInt8;                                    { Must be set to 0 }
  157.         portName:                PPCPortPtr;                                { 46 -->   PortName for PPC }
  158.         locationName:            LocationNamePtr;                        { 50 -->   If NBP Registration is required }
  159.         networkVisible:            BOOLEAN;                                { 54 -->   make this network visible on network }
  160.         nbpRegistered:            BOOLEAN;                                { 55 <--   The given location name was registered on the network }
  161.     END;
  162.  
  163.     PPCOpenPBPtr = ^PPCOpenPBRec;
  164.  
  165.     PPCInformPBRec = PACKED RECORD
  166.         qLink:                    Ptr;
  167.         csCode:                    INTEGER;
  168.         intUse:                    INTEGER;
  169.         intUsePtr:                Ptr;
  170.         ioCompletion:            PPCCompUPP;
  171.         ioResult:                OSErr;
  172.         Reserved:                ARRAY [0..4] OF LONGINT;
  173.         portRefNum:                PPCPortRefNum;                            { 38 -->   Port Identifier }
  174.         sessRefNum:                PPCSessRefNum;                            { 40 <--   Session Reference }
  175.         serviceType:            PPCServiceType;                            { 44 <--   Status Flags for type of session, local, remote }
  176.         autoAccept:                BOOLEAN;                                { 45 -->   if true session will be accepted automatically }
  177.         portName:                PPCPortPtr;                                { 46 -->   Buffer for Source PPCPortRec }
  178.         locationName:            LocationNamePtr;                        { 50 -->   Buffer for Source LocationNameRec }
  179.         userName:                StringPtr;                                { 54 -->   Buffer for Soure user's name trying to link. }
  180.         userData:                LONGINT;                                { 58 <--   value included in PPCStart's userData }
  181.         requestType:            PPCSessionOrigin;                        { 62 <--   Local or Network }
  182.     END;
  183.  
  184.     PPCInformPBPtr = ^PPCInformPBRec;
  185.  
  186.     PPCStartPBRec = PACKED RECORD
  187.         qLink:                    Ptr;
  188.         csCode:                    INTEGER;
  189.         intUse:                    INTEGER;
  190.         intUsePtr:                Ptr;
  191.         ioCompletion:            PPCCompUPP;
  192.         ioResult:                OSErr;
  193.         Reserved:                ARRAY [0..4] OF LONGINT;
  194.         portRefNum:                PPCPortRefNum;                            { 38 -->   Port Identifier }
  195.         sessRefNum:                PPCSessRefNum;                            { 40 <--   Session Reference }
  196.         serviceType:            PPCServiceType;                            { 44 <--   Actual service method (realTime) }
  197.         resFlag:                UInt8;                                    { 45 -->   Must be set to 0  }
  198.         portName:                PPCPortPtr;                                { 46 -->   Destination portName }
  199.         locationName:            LocationNamePtr;                        { 50 -->   NBP or NAS style service location name }
  200.         rejectInfo:                LONGINT;                                { 54 <--   reason for rejecting the session request }
  201.         userData:                LONGINT;                                { 58 -->   Copied to destination PPCInform parameter block }
  202.         userRefNum:                LONGINT;                                { 62 -->   userRefNum (obtained during login process)  }
  203.     END;
  204.  
  205.     PPCStartPBPtr = ^PPCStartPBRec;
  206.  
  207.     PPCAcceptPBRec = RECORD
  208.         qLink:                    Ptr;
  209.         csCode:                    INTEGER;
  210.         intUse:                    INTEGER;
  211.         intUsePtr:                Ptr;
  212.         ioCompletion:            PPCCompUPP;
  213.         ioResult:                OSErr;
  214.         Reserved:                ARRAY [0..4] OF LONGINT;
  215.         filler1:                INTEGER;
  216.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  217.     END;
  218.  
  219.     PPCAcceptPBPtr = ^PPCAcceptPBRec;
  220.  
  221.     PPCRejectPBRec = RECORD
  222.         qLink:                    Ptr;
  223.         csCode:                    INTEGER;
  224.         intUse:                    INTEGER;
  225.         intUsePtr:                Ptr;
  226.         ioCompletion:            PPCCompUPP;
  227.         ioResult:                OSErr;
  228.         Reserved:                ARRAY [0..4] OF LONGINT;
  229.         filler1:                INTEGER;
  230.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  231.         filler2:                INTEGER;
  232.         filler3:                LONGINT;
  233.         filler4:                LONGINT;
  234.         rejectInfo:                LONGINT;                                { 54 -->   reason for rejecting the session request  }
  235.     END;
  236.  
  237.     PPCRejectPBPtr = ^PPCRejectPBRec;
  238.  
  239.     PPCWritePBRec = RECORD
  240.         qLink:                    Ptr;
  241.         csCode:                    INTEGER;
  242.         intUse:                    INTEGER;
  243.         intUsePtr:                Ptr;
  244.         ioCompletion:            PPCCompUPP;
  245.         ioResult:                OSErr;
  246.         Reserved:                ARRAY [0..4] OF LONGINT;
  247.         filler1:                INTEGER;
  248.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  249.         bufferLength:            Size;                                    { 44 -->   Length of the message buffer }
  250.         actualLength:            Size;                                    { 48 <--   Actual Length Written }
  251.         bufferPtr:                Ptr;                                    { 52 -->   Pointer to message buffer }
  252.         more:                    BOOLEAN;                                { 56 -->   if more data in this block will be written }
  253.         filler2:                SInt8; (* unsigned char *)
  254.         userData:                LONGINT;                                { 58 -->   Message block userData Uninterpreted by PPC }
  255.         blockCreator:            OSType;                                    { 62 -->   Message block creator Uninterpreted by PPC }
  256.         blockType:                OSType;                                    { 66 -->   Message block type Uninterpreted by PPC }
  257.     END;
  258.  
  259.     PPCWritePBPtr = ^PPCWritePBRec;
  260.  
  261.     PPCReadPBRec = RECORD
  262.         qLink:                    Ptr;
  263.         csCode:                    INTEGER;
  264.         intUse:                    INTEGER;
  265.         intUsePtr:                Ptr;
  266.         ioCompletion:            PPCCompUPP;
  267.         ioResult:                OSErr;
  268.         Reserved:                ARRAY [0..4] OF LONGINT;
  269.         filler1:                INTEGER;
  270.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  271.         bufferLength:            Size;                                    { 44 -->   Length of the message buffer }
  272.         actualLength:            Size;                                    { 48 <--   Actual length read }
  273.         bufferPtr:                Ptr;                                    { 52 -->   Pointer to message buffer }
  274.         more:                    BOOLEAN;                                { 56 <--   if true more data in this block to be read }
  275.         filler2:                SInt8; (* unsigned char *)
  276.         userData:                LONGINT;                                { 58 <--   Message block userData Uninterpreted by PPC }
  277.         blockCreator:            OSType;                                    { 62 <--   Message block creator Uninterpreted by PPC }
  278.         blockType:                OSType;                                    { 66 <--   Message block type Uninterpreted by PPC }
  279.     END;
  280.  
  281.     PPCReadPBPtr = ^PPCReadPBRec;
  282.  
  283.     PPCEndPBRec = RECORD
  284.         qLink:                    Ptr;
  285.         csCode:                    INTEGER;
  286.         intUse:                    INTEGER;
  287.         intUsePtr:                Ptr;
  288.         ioCompletion:            PPCCompUPP;
  289.         ioResult:                OSErr;
  290.         Reserved:                ARRAY [0..4] OF LONGINT;
  291.         filler1:                INTEGER;
  292.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  293.     END;
  294.  
  295.     PPCEndPBPtr = ^PPCEndPBRec;
  296.  
  297.     PPCClosePBRec = RECORD
  298.         qLink:                    Ptr;
  299.         csCode:                    INTEGER;
  300.         intUse:                    INTEGER;
  301.         intUsePtr:                Ptr;
  302.         ioCompletion:            PPCCompUPP;
  303.         ioResult:                OSErr;
  304.         Reserved:                ARRAY [0..4] OF LONGINT;
  305.         portRefNum:                PPCPortRefNum;                            { 38 -->   Port Identifier }
  306.     END;
  307.  
  308.     PPCClosePBPtr = ^PPCClosePBRec;
  309.  
  310.     IPCListPortsPBRec = RECORD
  311.         qLink:                    Ptr;
  312.         csCode:                    INTEGER;
  313.         intUse:                    INTEGER;
  314.         intUsePtr:                Ptr;
  315.         ioCompletion:            PPCCompUPP;
  316.         ioResult:                OSErr;
  317.         Reserved:                ARRAY [0..4] OF LONGINT;
  318.         filler1:                INTEGER;
  319.         startIndex:                INTEGER;                                { 40 -->   Start Index }
  320.         requestCount:            INTEGER;                                { 42 -->   Number of entries to be returned }
  321.         actualCount:            INTEGER;                                { 44 <--   Actual Number of entries to be returned }
  322.         portName:                PPCPortPtr;                                { 46 -->   PortName Match }
  323.         locationName:            LocationNamePtr;                        { 50 -->   NBP or NAS type name to locate the Port Location }
  324.         bufferPtr:                PortInfoArrayPtr;                        { 54 -->   Pointer to a buffer requestCount*sizeof(PortInfo) bytes big }
  325.     END;
  326.  
  327.     IPCListPortsPBPtr = ^IPCListPortsPBRec;
  328.  
  329.     PPCParamBlockRec = RECORD
  330.         CASE INTEGER OF
  331.         0: (
  332.             openParam:                    PPCOpenPBRec;
  333.            );
  334.         1: (
  335.             informParam:                PPCInformPBRec;
  336.            );
  337.         2: (
  338.             startParam:                    PPCStartPBRec;
  339.            );
  340.         3: (
  341.             acceptParam:                PPCAcceptPBRec;
  342.            );
  343.         4: (
  344.             rejectParam:                PPCRejectPBRec;
  345.            );
  346.         5: (
  347.             writeParam:                    PPCWritePBRec;
  348.            );
  349.         6: (
  350.             readParam:                    PPCReadPBRec;
  351.            );
  352.         7: (
  353.             endParam:                    PPCEndPBRec;
  354.            );
  355.         8: (
  356.             closeParam:                    PPCClosePBRec;
  357.            );
  358.         9: (
  359.             listPortsParam:                IPCListPortsPBRec;
  360.            );
  361.     END;
  362.  
  363.  
  364. FUNCTION PPCInit: OSErr;
  365.     {$IFC NOT GENERATINGCFM}
  366.     INLINE $7000, $A0DD, $3E80;
  367.     {$ENDC}
  368. FUNCTION PPCOpen(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  369. FUNCTION PPCOpenSync(pb: PPCOpenPBPtr): OSErr;
  370.     {$IFC NOT GENERATINGCFM}
  371.     INLINE $205F, $7001, $A0DD, $3E80;
  372.     {$ENDC}
  373. FUNCTION PPCOpenAsync(pb: PPCOpenPBPtr): OSErr;
  374.     {$IFC NOT GENERATINGCFM}
  375.     INLINE $205F, $7001, $A4DD, $3E80;
  376.     {$ENDC}
  377. FUNCTION PPCInform(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  378. FUNCTION PPCInformSync(pb: PPCInformPBPtr): OSErr;
  379.     {$IFC NOT GENERATINGCFM}
  380.     INLINE $205F, $7003, $A0DD, $3E80;
  381.     {$ENDC}
  382. FUNCTION PPCInformAsync(pb: PPCInformPBPtr): OSErr;
  383.     {$IFC NOT GENERATINGCFM}
  384.     INLINE $205F, $7003, $A4DD, $3E80;
  385.     {$ENDC}
  386. FUNCTION PPCStart(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  387. FUNCTION PPCStartSync(pb: PPCStartPBPtr): OSErr;
  388.     {$IFC NOT GENERATINGCFM}
  389.     INLINE $205F, $7002, $A0DD, $3E80;
  390.     {$ENDC}
  391. FUNCTION PPCStartAsync(pb: PPCStartPBPtr): OSErr;
  392.     {$IFC NOT GENERATINGCFM}
  393.     INLINE $205F, $7002, $A4DD, $3E80;
  394.     {$ENDC}
  395. FUNCTION PPCAccept(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  396. FUNCTION PPCAcceptSync(pb: PPCAcceptPBPtr): OSErr;
  397.     {$IFC NOT GENERATINGCFM}
  398.     INLINE $205F, $7004, $A0DD, $3E80;
  399.     {$ENDC}
  400. FUNCTION PPCAcceptAsync(pb: PPCAcceptPBPtr): OSErr;
  401.     {$IFC NOT GENERATINGCFM}
  402.     INLINE $205F, $7004, $A4DD, $3E80;
  403.     {$ENDC}
  404. FUNCTION PPCReject(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  405. FUNCTION PPCRejectSync(pb: PPCRejectPBPtr): OSErr;
  406.     {$IFC NOT GENERATINGCFM}
  407.     INLINE $205F, $7005, $A0DD, $3E80;
  408.     {$ENDC}
  409. FUNCTION PPCRejectAsync(pb: PPCRejectPBPtr): OSErr;
  410.     {$IFC NOT GENERATINGCFM}
  411.     INLINE $205F, $7005, $A4DD, $3E80;
  412.     {$ENDC}
  413. FUNCTION PPCWrite(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  414. FUNCTION PPCWriteSync(pb: PPCWritePBPtr): OSErr;
  415.     {$IFC NOT GENERATINGCFM}
  416.     INLINE $205F, $7006, $A0DD, $3E80;
  417.     {$ENDC}
  418. FUNCTION PPCWriteAsync(pb: PPCWritePBPtr): OSErr;
  419.     {$IFC NOT GENERATINGCFM}
  420.     INLINE $205F, $7006, $A4DD, $3E80;
  421.     {$ENDC}
  422. FUNCTION PPCRead(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  423. FUNCTION PPCReadSync(pb: PPCReadPBPtr): OSErr;
  424.     {$IFC NOT GENERATINGCFM}
  425.     INLINE $205F, $7007, $A0DD, $3E80;
  426.     {$ENDC}
  427. FUNCTION PPCReadAsync(pb: PPCReadPBPtr): OSErr;
  428.     {$IFC NOT GENERATINGCFM}
  429.     INLINE $205F, $7007, $A4DD, $3E80;
  430.     {$ENDC}
  431. FUNCTION PPCEnd(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  432. FUNCTION PPCEndSync(pb: PPCEndPBPtr): OSErr;
  433.     {$IFC NOT GENERATINGCFM}
  434.     INLINE $205F, $7008, $A0DD, $3E80;
  435.     {$ENDC}
  436. FUNCTION PPCEndAsync(pb: PPCEndPBPtr): OSErr;
  437.     {$IFC NOT GENERATINGCFM}
  438.     INLINE $205F, $7008, $A4DD, $3E80;
  439.     {$ENDC}
  440. FUNCTION PPCClose(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  441. FUNCTION PPCCloseSync(pb: PPCClosePBPtr): OSErr;
  442.     {$IFC NOT GENERATINGCFM}
  443.     INLINE $205F, $7009, $A0DD, $3E80;
  444.     {$ENDC}
  445. FUNCTION PPCCloseAsync(pb: PPCClosePBPtr): OSErr;
  446.     {$IFC NOT GENERATINGCFM}
  447.     INLINE $205F, $7009, $A4DD, $3E80;
  448.     {$ENDC}
  449. FUNCTION IPCListPorts(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  450. FUNCTION IPCListPortsSync(pb: IPCListPortsPBPtr): OSErr;
  451.     {$IFC NOT GENERATINGCFM}
  452.     INLINE $205F, $700A, $A0DD, $3E80;
  453.     {$ENDC}
  454. FUNCTION IPCListPortsAsync(pb: IPCListPortsPBPtr): OSErr;
  455.     {$IFC NOT GENERATINGCFM}
  456.     INLINE $205F, $700A, $A4DD, $3E80;
  457.     {$ENDC}
  458. FUNCTION DeleteUserIdentity(userRef: LONGINT): OSErr;
  459. FUNCTION GetDefaultUser(VAR userRef: LONGINT; VAR userName: Str32): OSErr;
  460. FUNCTION StartSecureSession(pb: PPCStartPBPtr; VAR userName: Str32; useDefault: BOOLEAN; allowGuest: BOOLEAN; VAR guestSelected: BOOLEAN; prompt: ConstStr255Param): OSErr;
  461. TYPE
  462.     PPCFilterProcPtr = ProcPtr;  { FUNCTION PPCFilter(name: LocationNamePtr; port: PortInfoPtr): BOOLEAN; }
  463.     PPCFilterUPP = UniversalProcPtr;
  464.  
  465. CONST
  466.     uppPPCCompProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  467.     uppPPCFilterProcInfo = $000003D0; { FUNCTION (4 byte param, 4 byte param): 1 byte result; }
  468.  
  469. FUNCTION NewPPCCompProc(userRoutine: PPCCompProcPtr): PPCCompUPP;
  470.     {$IFC NOT GENERATINGCFM }
  471.     INLINE $2E9F;
  472.     {$ENDC}
  473.  
  474. FUNCTION NewPPCFilterProc(userRoutine: PPCFilterProcPtr): PPCFilterUPP;
  475.     {$IFC NOT GENERATINGCFM }
  476.     INLINE $2E9F;
  477.     {$ENDC}
  478.  
  479. PROCEDURE CallPPCCompProc(pb: PPCParamBlockPtr; userRoutine: PPCCompUPP);
  480.     {$IFC NOT GENERATINGCFM}
  481.     INLINE $205F, $4E90;
  482.     {$ENDC}
  483.  
  484. FUNCTION CallPPCFilterProc(name: LocationNamePtr; port: PortInfoPtr; userRoutine: PPCFilterUPP): BOOLEAN;
  485.     {$IFC NOT GENERATINGCFM}
  486.     INLINE $205F, $4E90;
  487.     {$ENDC}
  488.  
  489. FUNCTION PPCBrowser(prompt: ConstStr255Param; applListLabel: ConstStr255Param; defaultSpecified: BOOLEAN; VAR theLocation: LocationNameRec; VAR thePortInfo: PortInfoRec; portFilter: PPCFilterUPP; theLocNBPType: ConstStr32Param): OSErr;
  490.     {$IFC NOT GENERATINGCFM}
  491.     INLINE $303C, $0D00, $A82B;
  492.     {$ENDC}
  493.  
  494. {$ALIGN RESET}
  495. {$POP}
  496.  
  497. {$SETC UsingIncludes := PPCToolboxIncludes}
  498.  
  499. {$ENDC} {__PPCTOOLBOX__}
  500.  
  501. {$IFC NOT UsingIncludes}
  502.  END.
  503. {$ENDC}
  504.